import sdk from '../index';
import { TaskConfig, TaskType, TaskTargetType, TaskTarget, TaskReward } from '../rpg/types/task';
import { ItemType, 资源枚举 } from '../../shared/face/enums';

/**
 * 世界任务管理器
 * 职责：
 * 1. 世界任务的生成和管理
 * 2. 世界任务数据的持久化
 * 3. 世界任务的清理和重置
 * 4. 世界任务模板的管理
 */
class WorldTaskManage {
    /** 世界任务数据库集合名称 */
    private readonly WORLD_TASK_COLLECTION = 'world_tasks';
    
    /** 世界任务内存缓存：Map<地图名称, Map<任务ID, 任务配置>> */
    private worldTaskCache: Map<string, Map<string, TaskConfig>> = new Map();
    
    /** 世界任务模板配置 */
    private readonly worldTaskTemplates: TaskConfig[] = [
        {
            id: 'world_kill_monsters',
            name: '清理怪物',
            description: '清理当前地图的怪物',
            type: TaskType.世界任务,
            targets: [
                {
                    type: TaskTargetType.击杀怪物,
                    count: 5,
                    current: 0,
                    description: '击杀5只怪物'
                }
            ],
            rewards: [
                {
                    type: ItemType.资源,
                    id: 资源枚举.经验,
                    count: 100,
                    name: '经验',
                    description: '获得100点经验'
                }
            ]
        },
        {
            id: 'world_explore_area',
            name: '探索地图',
            description: '探索当前地图',
            type: TaskType.世界任务,
            targets: [
                {
                    type: TaskTargetType.探索,
                    count: 1,
                    current: 0,
                    description: '探索10次'
                }
            ],
            rewards: [
                {
                    type: ItemType.资源,
                    id: '1',
                    count: 80,
                    name: '经验',
                    description: '获得80点经验'
                }
            ]
        },


    ];

    /**
     * 初始化世界任务管理器
     */
    async init() {
        try {
            console.log('初始化世界任务管理器...');
            
            // 加载世界任务数据到内存
            await this.loadWorldTasks();
            
            console.log('世界任务管理器初始化完成');
        } catch (error) {
            console.error('世界任务管理器初始化失败:', error);
        }
    }

    /**
     * 为指定地图生成世界任务
     * @param mapName 地图名称
     * @param playerId 玩家ID
     * @returns 生成的世界任务列表
     */
    async generateWorldTasks(mapName: string, playerId: string): Promise<TaskConfig[]> {
        // 主城不生成世界任务
        if (mapName === 'default' || mapName === '主城') {
            return [];
        }

        // 检查是否已有该地图的世界任务
        let mapTasks = this.worldTaskCache.get(mapName);
        if (!mapTasks) {
            mapTasks = new Map();
            this.worldTaskCache.set(mapName, mapTasks);
        }

        // 为玩家生成一个世界任务，包含多个目标
        const taskId = `world_task_${mapName}_${playerId}_${Date.now()}`;
        
        // 随机选择2-3个目标类型
        const targetTypes = [
            // TaskTargetType.击杀怪物,
            TaskTargetType.探索
        ];
        
        const shuffledTypes = targetTypes.sort(() => Math.random() - 0.5);
        const selectedTypes = shuffledTypes.slice(0, 1 + Math.floor(Math.random() * 2)); // 1-2个目标
        
        const targets = selectedTypes.map((type, index) => {
            switch (type) {
                case TaskTargetType.击杀怪物:
                    const killCount = 3 + Math.floor(Math.random() * 3); // 3-5只
                    return {
                        type: TaskTargetType.击杀怪物,
                        count: killCount,
                        current: 0,
                        description: `击杀${killCount}只怪物`
                    };
                case TaskTargetType.探索:
                    const exploreCount = 5 + Math.floor(Math.random() * 6); // 5-10次
                    return {
                        type: TaskTargetType.探索,
                        count: 1 + Math.floor(Math.random() * 1),
                        current: 0,
                        description: `探索${exploreCount}次`
                    };
                default:
                    return {
                        type: TaskTargetType.击杀怪物,
                        count: 3,
                        current: 0,
                        description: '击杀3只怪物'
                    };
            }
        });

        const rewards = [
            {
                type: ItemType.资源,
                id: "经验值",
                count: 50 + Math.floor(Math.random() * 50), // 50-100经验
                name: '经验值',
                description: '任务完成奖励'
            }
        ];

        const worldTask: TaskConfig = {
            id: taskId,
            name: `世界任务`,
            description: `在${mapName}地图中完成多个目标`,
            type: TaskType.世界任务,
            targets: targets,
            rewards: rewards
        };
        
        mapTasks.set(taskId, worldTask);
        console.log(`为地图 ${mapName} 的玩家 ${playerId} 生成了 1 个世界任务，包含 ${targets.length} 个目标`);

        return [worldTask];
    }

    /**
     * 获取指定地图的世界任务
     * @param mapName 地图名称
     * @returns 世界任务列表
     */
    getWorldTasks(mapName: string): TaskConfig[] {
        const mapTasks = this.worldTaskCache.get(mapName);
        if (!mapTasks) {
            return [];
        }
        return Array.from(mapTasks.values());
    }

    /**
     * 清理指定地图的世界任务
     * @param mapName 地图名称
     */
    async clearWorldTasks(mapName: string): Promise<void> {
        try {
            // 从内存中移除
            this.worldTaskCache.delete(mapName);
            
            // 从数据库中移除
            await sdk.db.remove(this.WORLD_TASK_COLLECTION, {
                mapName: mapName
            });
            
            console.log(`已清理地图 ${mapName} 的世界任务`);
        } catch (error) {
            console.error(`清理地图 ${mapName} 世界任务失败:`, error);
        }
    }

    /**
     * 清理指定玩家的世界任务
     * @param playerId 玩家ID
     */
    async clearPlayerWorldTasks(playerId: string): Promise<void> {
        try {
            // 从所有地图中移除该玩家的任务
            for (const [mapName, mapTasks] of this.worldTaskCache) {
                for (const [taskId, task] of mapTasks) {
                    if (taskId.includes(playerId)) {
                        mapTasks.delete(taskId);
                    }
                }
            }
            
            // 从数据库中移除
            await sdk.db.remove(this.WORLD_TASK_COLLECTION, {
                playerId: playerId
            });
            
            console.log(`已清理玩家 ${playerId} 的世界任务`);
        } catch (error) {
            console.error(`清理玩家 ${playerId} 世界任务失败:`, error);
        }
    }

    /**
     * 加载世界任务数据
     */
    private async loadWorldTasks(): Promise<void> {
        try {
            const worldTasks = await sdk.db.find(this.WORLD_TASK_COLLECTION);
            
            for (const taskData of worldTasks) {
                const mapName = taskData.mapName;
                let mapTasks = this.worldTaskCache.get(mapName);
                if (!mapTasks) {
                    mapTasks = new Map();
                    this.worldTaskCache.set(mapName, mapTasks);
                }
                
                mapTasks.set(taskData.taskId, taskData.taskConfig);
            }
            
            console.log(`加载了 ${worldTasks.length} 个世界任务`);
        } catch (error) {
            console.error('加载世界任务失败:', error);
        }
    }

    /**
     * 保存世界任务到数据库
     * @param mapName 地图名称
     * @param tasks 任务列表
     */
    private async saveWorldTasks(mapName: string, tasks: TaskConfig[]): Promise<void> {
        try {
            const taskDocuments = tasks.map(task => ({
                taskId: task.id,
                mapName: mapName,
                taskConfig: task,
                createdAt: new Date()
            }));

            for (const taskDoc of taskDocuments) {
                await sdk.db.insert(this.WORLD_TASK_COLLECTION, taskDoc);
            }
        } catch (error) {
            console.error('保存世界任务失败:', error);
        }
    }

    /**
     * 保存所有世界任务数据到数据库
     */
    async save(): Promise<void> {
        try {
            console.log('保存世界任务数据...');
            
            // 遍历所有地图的世界任务并保存
            for (const [mapName, mapTasks] of this.worldTaskCache) {
                const tasks = Array.from(mapTasks.values());
                if (tasks.length > 0) {
                    await this.saveWorldTasks(mapName, tasks);
                }
            }
            
            console.log('世界任务数据保存完成');
        } catch (error) {
            console.error('保存世界任务数据失败:', error);
        }
    }

    /**
     * 获取世界任务模板
     * @returns 世界任务模板列表
     */
    getWorldTaskTemplates(): TaskConfig[] {
        return [...this.worldTaskTemplates];
    }

    /**
     * 添加世界任务模板
     * @param template 任务模板
     */
    addWorldTaskTemplate(template: TaskConfig): void {
        this.worldTaskTemplates.push(template);
    }
}

const worldTaskManage = new WorldTaskManage();
export default worldTaskManage; 